import { expose } from 'threads/worker';
import { QueryTypes, Sequelize } from 'sequelize';
import { initDatabase } from './context';
import path from 'path';

// 在工作线程中初始化数据库连接
let sequelize: Sequelize;

// 初始化数据库连接
const initWorkerDatabase = async () => {
    if (!sequelize) {
        try {
            // 获取数据库路径，在打包环境中使用 process.cwd()
            let dbPath: string;
            if ((process as any).pkg) {
                // 在打包环境中，使用 exe 运行目录
                dbPath = path.join(process.cwd(), 'app', 'config', 'database-01.sqlite');
            } else {
                // 在开发环境中，使用相对路径
                dbPath = path.join(__dirname, '../config/database-01.sqlite');
            }
            initDatabase(dbPath, true); // 第二个参数表示这是工作线程
            
            // 等待一小段时间确保数据库初始化完成
            await new Promise(resolve => setTimeout(resolve, 100));
            
            // 重新导入sequelize实例
            const { sequelize: seq } = await import('./context');
            sequelize = seq;
            
            if (!sequelize) {
                throw new Error('数据库连接初始化失败');
            }
            
            console.log('[工作线程] 数据库连接初始化成功');
        } catch (error) {
            console.error('[工作线程] 数据库连接初始化失败:', error);
            throw error;
        }
    }
    return sequelize;
};

/**
 * 数据查询工作线程
 * 用于处理大量数据查询操作，避免阻塞主线程
 */
const dataQueryWorker = {
    /**
     * 获取分析记录数据
     */
    async getAnalyRecord(params: {
        startTime: string;
        endTime: string;
        module_id: number;
        module_type: string;
        gateway_ip: string;
    }) {
        try {
            console.log(`[工作线程] 开始查询分析数据 - 模块ID: ${params.module_id}, 类型: ${params.module_type}`);
            
            // 确保数据库连接已初始化
            const db = await initWorkerDatabase();
            
            const data = await db.query(`
                SELECT ${params.module_type},
                strftime('%Y-%m-%d %H:%M:%S',createdAt,'localtime') as timer,
                time, gateway_ip, module_id 
                FROM Data 
                WHERE module_id=${params.module_id} 
                    AND gateway_ip='${params.gateway_ip}'
                    AND timer > '${params.startTime}' 
                    AND timer < '${params.endTime}'
                ORDER BY createdAt ASC
            `, { type: QueryTypes.SELECT });
            
            console.log(`[工作线程] 查询完成 - 返回 ${data.length} 条记录`);
            
            return {
                success: true,
                data: data,
                total: data.length,
                module_id: params.module_id,
                module_type: params.module_type,
                date_range: {
                    start_time: params.startTime,
                    end_time: params.endTime,
                }
            };
        } catch (error) {
            console.error('[工作线程] 查询分析数据失败:', error);
            throw error;
        }
    },

    /**
     * 获取完整的传感器数据分析报告
     */
    async getCompleteAnalyRecord(params: {
        startTime: string;
        endTime: string;
        module_id: number;
        selectDate: string;
    }) {
        try {
            console.log(`[工作线程] 开始查询完整分析数据 - 模块ID: ${params.module_id}`);
            
            // 确保数据库连接已初始化
            const db = await initWorkerDatabase();
            
            const data = await db.query(`
                SELECT 
                tem, hum, pre, inf, uvc,
                strftime('%Y-%m-%d %H:%M:%S',createdAt,'localtime') as timer,
                time, gateway_ip, module_id, info
                FROM Data 
                WHERE module_id=${params.module_id} 
                    AND date='${params.selectDate}' 
                    AND timer > '${params.startTime}' 
                    AND timer < '${params.endTime}'
                ORDER BY createdAt ASC
            `, { type: QueryTypes.SELECT });
            
            console.log(`[工作线程] 完整查询完成 - 返回 ${data.length} 条记录`);
            
            return {
                success: true,
                data: data,
                total: data.length,
                module_id: params.module_id,
                sensor_types: ['tem', 'hum', 'pre', 'inf', 'uvc'],
                date_range: {
                    start_time: params.startTime,
                    end_time: params.endTime,
                    select_date: params.selectDate
                },
                description: {
                    tem: '温度数据',
                    hum: '湿度数据',
                    pre: '压力数据',
                    inf: '红外数据',
                    uvc: '紫外数据',
                    timer: '数据记录时间',
                    time: '数据采集时间',
                    gateway_ip: '网关IP地址',
                    module_id: '模块ID',
                    info: '原始数据信息'
                }
            };
        } catch (error) {
            console.error('[工作线程] 查询完整分析数据失败:', error);
            throw error;
        }
    },

    /**
     * 处理 UVC 数据拆解逻辑
     * 将包含逗号分隔的 UVC 数据拆解为多条记录
     */
    async processUvcData(data: any[], module_type: string) {
        try {
            console.log(`[工作线程] 开始处理 ${module_type} 数据拆解 - 原始数据 ${data.length} 条`);
            
            let mapArr: object[] = [];
            
            if (module_type === "uvc") {
                data.forEach((item: any) => {
                    if (item[module_type] && item[module_type].indexOf(",") !== -1) {
                        item[module_type].split(',').forEach((e: any, i: number) => {
                            mapArr.push({
                                uvc: e,
                                timer: item.timer + '-' + i * 100,
                                time: item.time + '-' + i * 100,
                                gateway_ip: item.gateway_ip,
                                module_id: item.module_id
                            });
                        });
                    } else {
                        mapArr.push({
                            uvc: item[module_type],
                            timer: item.timer,
                            time: item.time,
                            gateway_ip: item.gateway_ip,
                            module_id: item.module_id
                        });
                    }
                });
            } else {
                mapArr = data;
            }
            
            console.log(`[工作线程] 数据拆解完成 - 处理后数据 ${mapArr.length} 条`);
            return mapArr;
        } catch (error) {
            console.error('[工作线程] 数据拆解失败:', error);
            throw error;
        }
    },

    /**
     * 根据类型获取历史数据
     */
    async getHistoryDataByType(params: {
        gateway_ip: string;
        module_id: string;
        type: string;
        pageSize: number;
        page: number;
    }) {
        try {
            console.log(`[工作线程] 开始查询历史数据 - 网关: ${params.gateway_ip}, 模块: ${params.module_id}, 类型: ${params.type}`);
            
            const startPosition = (params.page - 1) * params.pageSize;
            
            // 验证type参数是否为有效的数据类型
            const validTypes = ['uvc', 'inf', 'tem', 'hum', 'pre'];
            if (!validTypes.includes(params.type)) {
                throw new Error(`无效的数据类型: ${params.type}，支持的类型: ${validTypes.join(', ')}`);
            }

            // 确保数据库连接已初始化
            const db = await initWorkerDatabase();
            
            // 查询指定类型的历史数据
            const data = await db.query(`
                SELECT 
                    ${params.type},
                    strftime('%Y-%m-%d %H:%M:%S', createdAt, 'localtime') as timer,
                    time,
                    gateway_ip,
                    module_id,
                    date
                FROM Data 
                WHERE gateway_ip = '${params.gateway_ip}' 
                    AND module_id = ${params.module_id}
                    AND ${params.type} IS NOT NULL
                    AND ${params.type} != ''
                ORDER BY createdAt DESC
                LIMIT ${params.pageSize} OFFSET ${startPosition}
            `, { type: QueryTypes.SELECT });

            // 获取总数
            const countResult = await db.query(`
                SELECT COUNT(*) as total
                FROM Data 
                WHERE gateway_ip = '${params.gateway_ip}' 
                    AND module_id = ${params.module_id}
                    AND ${params.type} IS NOT NULL
                    AND ${params.type} != ''
            `, { type: QueryTypes.SELECT });

            const total = (countResult[0] as any).total;
            
            console.log(`[工作线程] 历史数据查询完成 - 返回 ${data.length} 条记录，总计 ${total} 条`);

            return {
                data,
                total,
                pageSize: params.pageSize,
                currentPage: params.page,
                totalPages: Math.ceil(total / params.pageSize),
                gateway_ip: params.gateway_ip,
                module_id: params.module_id,
                dataType: params.type
            };
        } catch (error) {
            console.error('[工作线程] 获取历史数据失败:', error);
            throw error;
        }
    }
};

expose(dataQueryWorker);